#include "maingrid.h"
#include <QString>

// 构造函数实现
MainGrid::MainGrid(const QString& name, double maxImport, double maxExport)
    : Component(name, 1.0),  // 电网效率为1
    maxImportPower(maxImport),
    maxExportPower(maxExport),
    gridFrequency(50.0)    // 默认电网频率50Hz
{
    if (maxImportPower < 0) maxImportPower = 0;
    if (maxExportPower < 0) maxExportPower = 0;

    // 初始化电价曲线（默认分时电价）
    electricityPrice.resize(96); // 96个时间点（24小时，每15分钟一个）
    for (int i = 0; i < 96; ++i) {
        // 模拟分时电价：高峰、平段、低谷
        int hour = i / 4; // 转换为小时
        if (hour >= 7 && hour < 10) { // 早高峰
            electricityPrice[i] = 1.2;
        } else if (hour >= 10 && hour < 15) { // 平段
            electricityPrice[i] = 0.8;
        } else if (hour >= 15 && hour < 18) { // 晚高峰
            electricityPrice[i] = 1.2;
        } else if (hour >= 18 && hour < 21) { // 平段
            electricityPrice[i] = 0.8;
        } else { // 低谷
            electricityPrice[i] = 0.4;
        }
    }

    setActive(true); // 电网连接通常默认激活
    setPower(0);     // 初始功率交换为0
}

// 析构函数实现
MainGrid::~MainGrid()
{
    // 清理资源（如果有）
}

// 设置电价曲线
void MainGrid::setPriceProfile(const QVector<double>& prices)
{
    if (!prices.isEmpty()) {
        electricityPrice = prices;
    }
}

// 获取电价曲线
QVector<double> MainGrid::getPriceProfile() const
{
    return electricityPrice;
}

// 获取指定时间的电价
double MainGrid::getPriceAtTime(int timeIndex) const
{
    if (timeIndex >= 0 && timeIndex < electricityPrice.size()) {
        return electricityPrice[timeIndex];
    }
    return 0;
}

// 设置最大输入功率
void MainGrid::setMaxImportPower(double power)
{
    if (power >= 0) {
        maxImportPower = power;
    }
}

// 获取最大输入功率
double MainGrid::getMaxImportPower() const
{
    return maxImportPower;
}

// 设置最大输出功率
void MainGrid::setMaxExportPower(double power)
{
    if (power >= 0) {
        maxExportPower = power;
    }
}

// 获取最大输出功率
double MainGrid::getMaxExportPower() const
{
    return maxExportPower;
}

// 设置电网频率
void MainGrid::setGridFrequency(double frequency)
{
    gridFrequency = frequency;
}

// 获取电网频率
double MainGrid::getGridFrequency() const
{
    return gridFrequency;
}

// 计算当前成本（基于功率和电价）
double MainGrid::calculateCost(int timeIndex) const
{
    double price = getPriceAtTime(timeIndex);
    double power = getPower();

    // 从电网购电（功率为正）产生成本，向电网售电（功率为负）产生收益
    return power * price;
}

// 重写基类的设置功率方法，添加功率限制
void MainGrid::setPower(double newPower)
{
    // 限制功率在允许范围内
    if (newPower > 0) { // 从电网购电
        newPower = std::min(newPower, maxImportPower);
    } else { // 向电网售电
        newPower = std::max(newPower, -maxExportPower);
    }

    Component::setPower(newPower);
}

// 重写基类的获取状态方法
QString MainGrid::getStatus() const
{
    QString powerDirection;
    if (getPower() > 0) {
        powerDirection = "从电网购电";
    } else if (getPower() < 0) {
        powerDirection = "向电网售电";
    } else {
        powerDirection = "无功率交换";
    }

    return QString("%1\n%2\n最大输入功率: %3 kW\n最大输出功率: %4 kW\n电网频率: %5 Hz")
        .arg(Component::getStatus())
        .arg(powerDirection)
        .arg(maxImportPower)
        .arg(maxExportPower)
        .arg(gridFrequency);
}
